package com.chuxing.system.controller;

import cn.dev33.satoken.stp.StpUtil;
import com.chuxing.config.PermissionsState;
import com.chuxing.config.SecurityRole;
import com.chuxing.domain.DTO.ExamListDTO;
import com.chuxing.domain.Exam;
import com.chuxing.domain.Result;
import com.chuxing.domain.VO.PageResultVO;
import com.chuxing.exception.GenericException;
import com.chuxing.exception.UnauthorizedException;
import com.chuxing.system.service.IExamService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

/**
 * 笔试信息Controller
 *
 * @author 刘祺
 * @date 2024-12-08
 */
@RestController
@RequestMapping("/system/exam")
@RequiredArgsConstructor
@Tag(name = "笔试信息服务", description = "笔试信息服务相关接口")
public class ExamController
{
    private static final Logger log = LoggerFactory.getLogger(ExamController.class);
    @Autowired
    private IExamService examService;

    /**
     * 保存笔试信息
     */
    @Operation(summary = "保存笔试信息", description = "保存笔试信息")
    @PostMapping("/saveExamInfo")
    public Result<Object> saveExamInfo(@RequestBody Exam exam)
    {
        log.info("保存笔试信息{}", exam);
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 设置考试信息的学生ID为当前登录用户的ID
        exam.setStudentId(StpUtil.getLoginIdAsString());
        examService.saveExamInfo(exam);
        return Result.success("保存笔试信息成功");
    }
    /**
     * 获取笔试信息
     */
    @Operation(summary = "获取笔试信息", description = "获取笔试信息")
    @GetMapping("/getExamInfo")
    public Result<Exam> getExamInfo()
    {
        log.info("获取笔试信息");
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        Exam exam = examService.getExamInfo(StpUtil.getLoginIdAsString());
        log.info("获取笔试信息成功{}", exam);
        return Result.success("获取笔试信息成功", exam);
    }

    /**
     * 查询笔试信息列表
     */
    @Operation(summary = "管理员查询笔试信息列表", description = "管理员查询笔试信息列表")
    @GetMapping("/list")
    public Result<PageResultVO> list(ExamListDTO examListDTO)
    {
        log.info("管理员获取笔试列表{}", examListDTO);
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 检查用户是否具有管理员角色
        if (!StpUtil.hasRole(SecurityRole.ROLE_ADMIN)) {
            throw new GenericException(PermissionsState.PERMISSION_NOT_ENOUGH);
        }
        PageResultVO list = examService.selectExamList(examListDTO);
        log.info("管理员获取笔试列表成功{}", list);
        return Result.success("获取笔试列表成功", list);
    }

    /**
     * 导出笔试信息列表
     */
    @Operation(summary = "导出笔试信息列表", description = "导出笔试信息列表")
    @PostMapping("/export")
    public void export(HttpServletResponse response, @RequestBody ExamListDTO examListDTO) {
        // 记录导出日志
        log.info("管理员导出笔试信息列表");
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 检查用户是否具有管理员角色
        if (!StpUtil.hasRole(SecurityRole.ROLE_ADMIN)) {
            throw new GenericException(PermissionsState.PERMISSION_NOT_ENOUGH);
        }
        examService.export(response, examListDTO);
    }

    /**
     * 获取笔试信息详细信息
     */
    @Operation(summary = "管理员获取笔试信息详细信息", description = "管理员根据考试及面试时间ID获取详细信息")
    @GetMapping(value = "/{examId}")
    public Result<Exam> getInfo(@PathVariable("examId") Long examId)
    {
        log.info("管理员获取笔试信息详细信息，参数为：{}", examId);
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 检查用户是否具有管理员角色
        if (!StpUtil.hasRole(SecurityRole.ROLE_ADMIN)) {
            throw new GenericException(PermissionsState.PERMISSION_NOT_ENOUGH);
        }
        return Result.success("管理员获取笔试信息成功",examService.selectExamByExamId(examId));
    }

    /**
     * 新增笔试信息
     */
    @Operation(summary = "管理员新增笔试信息", description = "管理员新增笔试信息")
    @PostMapping
    public Result<Object> add(@RequestBody Exam exam)
    {
        log.info("管理员新增笔试信息{}", exam);
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 检查用户是否具有管理员角色
        if (!StpUtil.hasRole(SecurityRole.ROLE_ADMIN)) {
            throw new GenericException(PermissionsState.PERMISSION_NOT_ENOUGH);
        }
        examService.insertExam(exam);
        return Result.success("管理员新增笔试信息成功");
    }

    /**
     * 修改笔试信息
     */
    @Operation(summary = "管理员修改笔试信息", description = "管理员修改笔试信息")
    @PutMapping
    public Result<Object> edit(@RequestBody Exam exam)
    {
        log.info("管理员修改笔试信息{}", exam);
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 检查用户是否具有管理员角色
        if (!StpUtil.hasRole(SecurityRole.ROLE_ADMIN)) {
            throw new GenericException(PermissionsState.PERMISSION_NOT_ENOUGH);
        }
        examService.updateExam(exam);
        return Result.success("管理员修改笔试信息成功");
    }

    /**
     * 删除笔试信息
     */
    @Operation(summary = "管理员删除笔试信息", description = "管理员根据考试及面试时间ID删除笔试信息")
	@DeleteMapping("/{examIds}")
    public Result<Object> remove(@PathVariable Long[] examIds)
    {
        log.info("管理员删除笔试信息{}", examIds);
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 检查用户是否具有管理员角色
        if (!StpUtil.hasRole(SecurityRole.ROLE_ADMIN)) {
            throw new GenericException(PermissionsState.PERMISSION_NOT_ENOUGH);
        }
        examService.deleteExamByExamIds(examIds);
        return Result.success("管理员删除笔试信息成功");
    }

    /**
     * 清除笔试信息
     */
    @Operation(summary = "清除笔试信息", description = "清除笔试信息")
    @DeleteMapping("/clear")
    public Result<Object> clear()
    {
        log.info("清除笔试信息");
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 调用服务层方法，清除笔试信息
        examService.clear(StpUtil.getLoginIdAsString());
        return Result.success("清除笔试信息成功");
    }

    /**
     * 上传excel文件
     */
    @Operation(summary = "上传excel文件", description = "上传excel文件")
    @PostMapping("/upload")
    public Result<Object> upload(@RequestParam("file") MultipartFile file) {
        log.info("上传excel文件");
        // 检查用户是否已登录
        if (!StpUtil.isLogin()) {
            throw new UnauthorizedException(PermissionsState.NOT_LOGIN);
        }
        // 检查用户是否具有管理员角色
        if (!StpUtil.hasRole(SecurityRole.ROLE_ADMIN)) {
            throw new GenericException(PermissionsState.PERMISSION_NOT_ENOUGH);
        }
        // 调用服务层方法，上传excel文件
        examService.upload(file);
        return Result.success("上传excel文件成功");
    }
}
